home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Developer Essentials / MPW Interfaces & Libraries / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1992-01-29  |  27.8 KB  |  1,002 lines  |  [TEXT/MPS ]
  1.  
  2. {
  3. Created: Monday, September 16, 1991 at 12:15 AM
  4.  Quickdraw.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.   Copyright Apple Computer, Inc. 1985-1991
  8.   All rights reserved
  9. }
  10.  
  11.  
  12. {$IFC UNDEFINED UsingIncludes}
  13. {$SETC UsingIncludes := 0}
  14. {$ENDC}
  15.  
  16. {$IFC NOT UsingIncludes}
  17.  UNIT Quickdraw;
  18.  INTERFACE
  19. {$ENDC}
  20.  
  21. {$IFC UNDEFINED UsingQuickdraw}
  22. {$SETC UsingQuickdraw := 1}
  23.  
  24. {$I+}
  25. {$SETC QuickdrawIncludes := UsingIncludes}
  26. {$SETC UsingIncludes := 1}
  27. {$IFC UNDEFINED UsingTypes}
  28. {$I $$Shell(PInterfaces)Types.p}
  29. {$ENDC}
  30. {$SETC UsingIncludes := QuickdrawIncludes}
  31.  
  32. CONST
  33. invalColReq = -1;                            {invalid color table request}
  34.  
  35. { transfer modes }
  36. srcCopy = 0;                                {the 16 transfer modes}
  37. srcOr = 1;
  38. srcXor = 2;
  39. srcBic = 3;
  40. notSrcCopy = 4;
  41. notSrcOr = 5;
  42. notSrcXor = 6;
  43. notSrcBic = 7;
  44. patCopy = 8;
  45. patOr = 9;
  46. patXor = 10;
  47. patBic = 11;
  48. notPatCopy = 12;
  49. notPatOr = 13;
  50. notPatXor = 14;
  51. notPatBic = 15;
  52.  
  53. { Special Text Transfer Mode }
  54. grayishTextOr = 49;
  55.  
  56. { Arithmetic transfer modes }
  57. blend = 32;
  58. addPin = 33;
  59. addOver = 34;
  60. subPin = 35;
  61. addMax = 37;
  62. adMax = 37;
  63. subOver = 38;
  64. adMin = 39;
  65. ditherCopy = 64;
  66.  
  67. { Transparent mode constant }
  68. transparent = 36;
  69.  
  70. { QuickDraw color separation constants }
  71. normalBit = 0;                                {normal screen mapping}
  72. inverseBit = 1;                                {inverse screen mapping}
  73. redBit = 4;                                    {RGB additive mapping}
  74. greenBit = 3;
  75. blueBit = 2;
  76. cyanBit = 8;                                {CMYBk subtractive mapping}
  77. magentaBit = 7;
  78. yellowBit = 6;
  79. blackBit = 5;
  80. blackColor = 33;                            {colors expressed in these mappings}
  81. whiteColor = 30;
  82. redColor = 205;
  83. greenColor = 341;
  84. blueColor = 409;
  85. cyanColor = 273;
  86. magentaColor = 137;
  87. yellowColor = 69;
  88.  
  89. picLParen = 0;                                {standard picture comments}
  90. picRParen = 1;
  91.  
  92.  
  93. clutType = 0;                                {0 if lookup table}
  94. fixedType = 1;                                {1 if fixed table}
  95. directType = 2;                                {2 if direct values}
  96.  
  97. gdDevType = 0;                                {0 = monochrome 1 = color}
  98. burstDevice = 7;
  99. ext32Device = 8;
  100. ramInit = 10;                                {1 if initialized from 'scrn' resource}
  101. mainScreen = 11;                            { 1 if main screen }
  102. allInit = 12;                                { 1 if all devices initialized }
  103. screenDevice = 13;                            {1 if screen device [not used]}
  104. noDriver = 14;                                { 1 if no driver for this GDevice }
  105. screenActive = 15;                            {1 if in use}
  106.  
  107. hiliteBit = 7;                                {flag bit in HiliteMode (lowMem flag)}
  108. pHiliteBit = 0;                                {flag bit in HiliteMode used with BitClr procedure}
  109.  
  110. defQDColors = 127;                            {resource ID of clut for default QDColors}
  111.  
  112. { pixel type }
  113. RGBDirect = 16;                                { 16 & 32 bits/pixel pixelType value }
  114.  
  115. { pmVersion values }
  116. baseAddr32 = 4;                                {pixmap base address is 32-bit address}
  117.  
  118. rgnOverflowErr = -147;                        { Region accumulation failed. Resulting region may be currupt }
  119. insufficientStackErr = -149;                { QuickDraw could not complete the operation }
  120.  
  121. TYPE
  122. GrafVerb = (frame,paint,erase,invert,fill);
  123.  
  124. PixelType = (chunky,chunkyPlanar,planar);
  125.  
  126.  
  127.  
  128. PatPtr = ^Pattern;
  129. PatHandle = ^PatPtr;
  130.  
  131. Pattern = PACKED ARRAY [0..7] OF 0..255;
  132.  
  133. QDByte = SignedByte;
  134.  
  135. QDPtr = Ptr;                                { blind pointer }
  136.  
  137. QDHandle = Handle;                            { blind handle }
  138.  
  139.  
  140.  
  141. QDErr = INTEGER;
  142.  
  143. Bits16 = ARRAY [0..15] OF INTEGER;
  144.  
  145.  
  146. StyleItem = (bold,italic,underline,outline,shadow,condense,extend);
  147.  
  148.  
  149. Style = SET OF StyleItem;
  150.  
  151.  
  152. DeviceLoopFlags = SET OF (singleDevices,dontMatchSeeds,allDevices,DeviceLoopFlags3,
  153.  DeviceLoopFlags4,DeviceLoopFlags5,DeviceLoopFlags6,DeviceLoopFlags7,DeviceLoopFlags8,
  154.  DeviceLoopFlags9,DeviceLoopFlags10,DeviceLoopFlags11,DeviceLoopFlags12,
  155.  DeviceLoopFlags13,DeviceLoopFlags14,DeviceLoopFlags15,DeviceLoopFlags16,
  156.  DeviceLoopFlags17,DeviceLoopFlags18,DeviceLoopFlags19,DeviceLoopFlags20,
  157.  DeviceLoopFlags21,DeviceLoopFlags22,DeviceLoopFlags23,DeviceLoopFlags24,
  158.  DeviceLoopFlags25,DeviceLoopFlags26,DeviceLoopFlags27,DeviceLoopFlags28,
  159.  DeviceLoopFlags29,DeviceLoopFlags30,DeviceLoopFlags31);
  160.  
  161.  
  162. FontInfo = RECORD
  163.  ascent: INTEGER;
  164.  descent: INTEGER;
  165.  widMax: INTEGER;
  166.  leading: INTEGER;
  167.  END;
  168.  
  169. BitMapPtr = ^BitMap;
  170. BitMapHandle = ^BitMapPtr;
  171. BitMap = RECORD
  172.  baseAddr: Ptr;
  173.  rowBytes: INTEGER;
  174.  bounds: Rect;
  175.  END;
  176.  
  177. CursPtr = ^Cursor;
  178. CursHandle = ^CursPtr;
  179. Cursor = RECORD
  180.  data: Bits16;
  181.  mask: Bits16;
  182.  hotSpot: Point;
  183.  END;
  184.  
  185. PenState = RECORD
  186.  pnLoc: Point;
  187.  pnSize: Point;
  188.  pnMode: INTEGER;
  189.  pnPat: Pattern;
  190.  END;
  191.  
  192. RgnPtr = ^Region;
  193. RgnHandle = ^RgnPtr;
  194. Region = RECORD
  195.  rgnSize: INTEGER;                            {size in bytes}
  196.  rgnBBox: Rect;                                {enclosing rectangle}
  197.  END;
  198.  
  199. PicPtr = ^Picture;
  200. PicHandle = ^PicPtr;
  201. Picture = RECORD
  202.  picSize: INTEGER;
  203.  picFrame: Rect;
  204.  END;
  205.  
  206. PolyPtr = ^Polygon;
  207. PolyHandle = ^PolyPtr;
  208. Polygon = RECORD
  209.  polySize: INTEGER;
  210.  polyBBox: Rect;
  211.  polyPoints: ARRAY [0..0] OF Point;
  212.  END;
  213.  
  214. QDProcsPtr = ^QDProcs;
  215. QDProcs = RECORD
  216.  textProc: Ptr;
  217.  lineProc: Ptr;
  218.  rectProc: Ptr;
  219.  rRectProc: Ptr;
  220.  ovalProc: Ptr;
  221.  arcProc: Ptr;
  222.  polyProc: Ptr;
  223.  rgnProc: Ptr;
  224.  bitsProc: Ptr;
  225.  commentProc: Ptr;
  226.  txMeasProc: Ptr;
  227.  getPicProc: Ptr;
  228.  putPicProc: Ptr;
  229.  END;
  230.  
  231. GrafPtr = ^GrafPort;
  232. GrafPort = RECORD
  233.  device: INTEGER;
  234.  portBits: BitMap;
  235.  portRect: Rect;
  236.  visRgn: RgnHandle;
  237.  clipRgn: RgnHandle;
  238.  bkPat: Pattern;
  239.  fillPat: Pattern;
  240.  pnLoc: Point;
  241.  pnSize: Point;
  242.  pnMode: INTEGER;
  243.  pnPat: Pattern;
  244.  pnVis: INTEGER;
  245.  txFont: INTEGER;
  246.  txFace: Style;                                {txFace is unpacked byte but push as short}
  247.  txMode: INTEGER;
  248.  txSize: INTEGER;
  249.  spExtra: Fixed;
  250.  fgColor: LONGINT;
  251.  bkColor: LONGINT;
  252.  colrBit: INTEGER;
  253.  patStretch: INTEGER;
  254.  picSave: Handle;
  255.  rgnSave: Handle;
  256.  polySave: Handle;
  257.  grafProcs: QDProcsPtr;
  258.  END;
  259.  
  260.  
  261. WindowPtr = GrafPtr;
  262.  
  263. {typedef pascal Boolean (*ColorSearchProcPtr)(RGBColor *rgb, long *position);
  264. typedef pascal Boolean (*ColorComplementProcPtr)(RGBColor *rgb);}
  265.  
  266. RGBColor = RECORD
  267.  red: INTEGER;                                {magnitude of red component}
  268.  green: INTEGER;                            {magnitude of green component}
  269.  blue: INTEGER;                                {magnitude of blue component}
  270.  END;
  271.  
  272. ColorSpecPtr = ^ColorSpec;
  273. ColorSpec = RECORD
  274.  value: INTEGER;                            {index or other value}
  275.  rgb: RGBColor;                                {true color}
  276.  END;
  277.  
  278.  
  279. CSpecArray = ARRAY [0..0] OF ColorSpec;
  280.  
  281. CTabPtr = ^ColorTable;
  282. CTabHandle = ^CTabPtr;
  283. ColorTable = RECORD
  284.  ctSeed: LONGINT;                            {unique identifier for table}
  285.  ctFlags: INTEGER;                            {high bit: 0 = PixMap; 1 = device}
  286.  ctSize: INTEGER;                            {number of entries in CTTable}
  287.  ctTable: CSpecArray;                        {array [0..0] of ColorSpec}
  288.  END;
  289.  
  290. MatchRec = RECORD
  291.  red: INTEGER;
  292.  green: INTEGER;
  293.  blue: INTEGER;
  294.  matchData: LONGINT;
  295.  END;
  296.  
  297. PixMapPtr = ^PixMap;
  298. PixMapHandle = ^PixMapPtr;
  299. PixMap = RECORD
  300.  baseAddr: Ptr;                                {pointer to pixels}
  301.  rowBytes: INTEGER;                            {offset to next line}
  302.  bounds: Rect;                                {encloses bitmap}
  303.  pmVersion: INTEGER;                        {pixMap version number}
  304.  packType: INTEGER;                            {defines packing format}
  305.  packSize: LONGINT;                            {length of pixel data}
  306.  hRes: Fixed;                                {horiz. resolution (ppi)}
  307.  vRes: Fixed;                                {vert. resolution (ppi)}
  308.  pixelType: INTEGER;                        {defines pixel type}
  309.  pixelSize: INTEGER;                        {# bits in pixel}
  310.  cmpCount: INTEGER;                            {# components in pixel}
  311.  cmpSize: INTEGER;                            {# bits per component}
  312.  planeBytes: LONGINT;                        {offset to next plane}
  313.  pmTable: CTabHandle;                        {color map for this pixMap}
  314.  pmReserved: LONGINT;                        {for future use. MUST BE 0}
  315.  END;
  316.  
  317. PixPatPtr = ^PixPat;
  318. PixPatHandle = ^PixPatPtr;
  319. PixPat = RECORD
  320.  patType: INTEGER;                            {type of pattern}
  321.  patMap: PixMapHandle;                        {the pattern's pixMap}
  322.  patData: Handle;                            {pixmap's data}
  323.  patXData: Handle;                            {expanded Pattern data}
  324.  patXValid: INTEGER;                        {flags whether expanded Pattern valid}
  325.  patXMap: Handle;                            {Handle to expanded Pattern data}
  326.  pat1Data: Pattern;                            {old-Style pattern/RGB color}
  327.  END;
  328.  
  329. CCrsrPtr = ^CCrsr;
  330. CCrsrHandle = ^CCrsrPtr;
  331. CCrsr = RECORD
  332.  crsrType: INTEGER;                            {type of cursor}
  333.  crsrMap: PixMapHandle;                        {the cursor's pixmap}
  334.  crsrData: Handle;                            {cursor's data}
  335.  crsrXData: Handle;                            {expanded cursor data}
  336.  crsrXValid: INTEGER;                        {depth of expanded data (0 if none)}
  337.  crsrXHandle: Handle;                        {future use}
  338.  crsr1Data: Bits16;                            {one-bit cursor}
  339.  crsrMask: Bits16;                            {cursor's mask}
  340.  crsrHotSpot: Point;                        {cursor's hotspot}
  341.  crsrXTable: LONGINT;                        {private}
  342.  crsrID: LONGINT;                            {private}
  343.  END;
  344.  
  345. CIconPtr = ^CIcon;
  346. CIconHandle = ^CIconPtr;
  347. CIcon = RECORD
  348.  iconPMap: PixMap;                            {the icon's pixMap}
  349.  iconMask: BitMap;                            {the icon's mask}
  350.  iconBMap: BitMap;                            {the icon's bitMap}
  351.  iconData: Handle;                            {the icon's data}
  352.  iconMaskData: ARRAY [0..0] OF INTEGER;        {icon's mask and BitMap data}
  353.  END;
  354.  
  355. GammaTblPtr = ^GammaTbl;
  356. GammaTblHandle = ^GammaTblPtr;
  357. GammaTbl = RECORD
  358.  gVersion: INTEGER;                            {gamma version number}
  359.  gType: INTEGER;                            {gamma data type}
  360.  gFormulaSize: INTEGER;                        {Formula data size}
  361.  gChanCnt: INTEGER;                            {number of channels of data}
  362.  gDataCnt: INTEGER;                            {number of values/channel}
  363.  gDataWidth: INTEGER;                        {bits/corrected value (data packed to next larger byte size)}
  364.  gFormulaData: ARRAY [0..0] OF INTEGER;        {data for formulas followed by gamma values}
  365.  END;
  366.  
  367. ITabPtr = ^ITab;
  368. ITabHandle = ^ITabPtr;
  369. ITab = RECORD
  370.  iTabSeed: LONGINT;                            {copy of CTSeed from source CTable}
  371.  iTabRes: INTEGER;                            {bits/channel resolution of iTable}
  372.  iTTable: ARRAY [0..0] OF SignedByte;        {byte colortable index values}
  373.  END;
  374.  
  375. SProcPtr = ^SProcRec;
  376. SProcHndl = ^SProcPtr;
  377. SProcRec = RECORD
  378.  nxtSrch: Handle;                            {SProcHndl Handle to next SProcRec}
  379.  srchProc: ProcPtr;                            {pointer to search procedure}
  380.  END;
  381.  
  382. CProcPtr = ^CProcRec;
  383. CProcHndl = ^CProcPtr;
  384. CProcRec = RECORD
  385.  nxtComp: CProcHndl;                        {CProcHndl Handle to next CProcRec}
  386.  compProc: ProcPtr;                            {pointer to complement procedure}
  387.  END;
  388.  
  389. GDPtr = ^GDevice;
  390. GDHandle = ^GDPtr;
  391. GDevice = RECORD
  392.  gdRefNum: INTEGER;                            {driver's unit number}
  393.  gdID: INTEGER;                                {client ID for search procs}
  394.  gdType: INTEGER;                            {fixed/CLUT/direct}
  395.  gdITable: ITabHandle;                        {Handle to inverse lookup table}
  396.  gdResPref: INTEGER;                        {preferred resolution of GDITable}
  397.  gdSearchProc: SProcHndl;                    {search proc list head}
  398.  gdCompProc: CProcHndl;                        {complement proc list}
  399.  gdFlags: INTEGER;                            {grafDevice flags word}
  400.  gdPMap: PixMapHandle;                        {describing pixMap}
  401.  gdRefCon: LONGINT;                            {reference value}
  402.  gdNextGD: GDHandle;                        {GDHandle Handle of next gDevice}
  403.  gdRect: Rect;                                { device's bounds in global coordinates}
  404.  gdMode: LONGINT;                            {device's current mode}
  405.  gdCCBytes: INTEGER;                        {depth of expanded cursor data}
  406.  gdCCDepth: INTEGER;                        {depth of expanded cursor data}
  407.  gdCCXData: Handle;                            {Handle to cursor's expanded data}
  408.  gdCCXMask: Handle;                            {Handle to cursor's expanded mask}
  409.  gdReserved: LONGINT;                        {future use. MUST BE 0}
  410.  END;
  411.  
  412. GVarPtr = ^GrafVars;
  413. GVarHandle = ^GVarPtr;
  414. GrafVars = RECORD
  415.  rgbOpColor: RGBColor;                        {color for addPin  subPin and average}
  416.  rgbHiliteColor: RGBColor;                    {color for hiliting}
  417.  pmFgColor: Handle;                            {palette Handle for foreground color}
  418.  pmFgIndex: INTEGER;                        {index value for foreground}
  419.  pmBkColor: Handle;                            {palette Handle for background color}
  420.  pmBkIndex: INTEGER;                        {index value for background}
  421.  pmFlags: INTEGER;                            {flags for Palette Manager}
  422.  END;
  423.  
  424. CQDProcsPtr = ^CQDProcs;
  425. CQDProcs = RECORD
  426.  textProc: Ptr;
  427.  lineProc: Ptr;
  428.  rectProc: Ptr;
  429.  rRectProc: Ptr;
  430.  ovalProc: Ptr;
  431.  arcProc: Ptr;
  432.  polyProc: Ptr;
  433.  rgnProc: Ptr;
  434.  bitsProc: Ptr;
  435.  commentProc: Ptr;
  436.  txMeasProc: Ptr;
  437.  getPicProc: Ptr;
  438.  putPicProc: Ptr;
  439.  opcodeProc: Ptr;                            {fields added to QDProcs}
  440.  newProc1: Ptr;
  441.  newProc2: Ptr;
  442.  newProc3: Ptr;
  443.  newProc4: Ptr;
  444.  newProc5: Ptr;
  445.  newProc6: Ptr;
  446.  END;
  447.  
  448. CGrafPtr = ^CGrafPort;
  449. CGrafPort = RECORD
  450.  device: INTEGER;
  451.  portPixMap: PixMapHandle;                    {port's pixel map}
  452.  portVersion: INTEGER;                        {high 2 bits always set}
  453.  grafVars: Handle;                            {Handle to more fields}
  454.  chExtra: INTEGER;                            {character extra}
  455.  pnLocHFrac: INTEGER;                        {pen fraction}
  456.  portRect: Rect;
  457.  visRgn: RgnHandle;
  458.  clipRgn: RgnHandle;
  459.  bkPixPat: PixPatHandle;                    {background pattern}
  460.  rgbFgColor: RGBColor;                        {RGB components of fg}
  461.  rgbBkColor: RGBColor;                        {RGB components of bk}
  462.  pnLoc: Point;
  463.  pnSize: Point;
  464.  pnMode: INTEGER;
  465.  pnPixPat: PixPatHandle;                    {pen's pattern}
  466.  fillPixPat: PixPatHandle;                    {fill pattern}
  467.  pnVis: INTEGER;
  468.  txFont: INTEGER;
  469.  txFace: Style;                                {txFace is unpacked byte  push as short}
  470.  txMode: INTEGER;
  471.  txSize: INTEGER;
  472.  spExtra: Fixed;
  473.  fgColor: LONGINT;
  474.  bkColor: LONGINT;
  475.  colrBit: INTEGER;
  476.  patStretch: INTEGER;
  477.  picSave: Handle;
  478.  rgnSave: Handle;
  479.  polySave: Handle;
  480.  grafProcs: CQDProcsPtr;
  481.  END;
  482.  
  483.  
  484. CWindowPtr = CGrafPtr;
  485.  
  486. ReqListRec = RECORD
  487.  reqLSize: INTEGER;                            {request list size}
  488.  reqLData: ARRAY [0..0] OF INTEGER;            {request list data}
  489.  END;
  490.  
  491. OpenCPicParams = RECORD
  492.  srcRect: Rect;
  493.  hRes: Fixed;
  494.  vRes: Fixed;
  495.  version: INTEGER;
  496.  reserved1: INTEGER;
  497.  reserved2: LONGINT;
  498.  END;
  499.  
  500.  
  501. DeviceLoopDrawingProcPtr = ProcPtr;
  502.  
  503.  
  504. VAR
  505. {$PUSH}
  506. {$J+}
  507.  thePort: GrafPtr;
  508.  white: Pattern;
  509.  black: Pattern;
  510.  gray: Pattern;
  511.  ltGray: Pattern;
  512.  dkGray: Pattern;
  513.  arrow: Cursor;
  514.  screenBits: BitMap;
  515.  randSeed: LONGINT;
  516. {$POP}
  517.  
  518.  
  519. PROCEDURE InitGraf(globalPtr: Ptr);
  520.  INLINE $A86E;
  521. PROCEDURE OpenPort(port: GrafPtr);
  522.  INLINE $A86F;
  523. PROCEDURE InitPort(port: GrafPtr);
  524.  INLINE $A86D;
  525. PROCEDURE ClosePort(port: GrafPtr);
  526.  INLINE $A87D;
  527. PROCEDURE SetPort(port: GrafPtr);
  528.  INLINE $A873;
  529. PROCEDURE GetPort(VAR port: GrafPtr);
  530.  INLINE $A874;
  531. PROCEDURE GrafDevice(device: INTEGER);
  532.  INLINE $A872;
  533. PROCEDURE SetPortBits(bm: BitMap);
  534.  INLINE $A875;
  535. PROCEDURE PortSize(width: INTEGER;height: INTEGER);
  536.  INLINE $A876;
  537. PROCEDURE MovePortTo(leftGlobal: INTEGER;topGlobal: INTEGER);
  538.  INLINE $A877;
  539. PROCEDURE SetOrigin(h: INTEGER;v: INTEGER);
  540.  INLINE $A878;
  541. PROCEDURE SetClip(rgn: RgnHandle);
  542.  INLINE $A879;
  543. PROCEDURE GetClip(rgn: RgnHandle);
  544.  INLINE $A87A;
  545. PROCEDURE ClipRect(r: Rect);
  546.  INLINE $A87B;
  547. PROCEDURE BackPat(pat: Pattern);
  548.  INLINE $A87C;
  549. PROCEDURE InitCursor;
  550.  INLINE $A850;
  551. PROCEDURE SetCursor(crsr: Cursor);
  552.  INLINE $A851;
  553. PROCEDURE HideCursor;
  554.  INLINE $A852;
  555. PROCEDURE ShowCursor;
  556.  INLINE $A853;
  557. PROCEDURE ObscureCursor;
  558.  INLINE $A856;
  559. PROCEDURE HidePen;
  560.  INLINE $A896;
  561. PROCEDURE ShowPen;
  562.  INLINE $A897;
  563. PROCEDURE GetPen(VAR pt: Point);
  564.  INLINE $A89A;
  565. PROCEDURE GetPenState(VAR pnState: PenState);
  566.  INLINE $A898;
  567. PROCEDURE SetPenState(pnState: PenState);
  568.  INLINE $A899;
  569. PROCEDURE PenSize(width: INTEGER;height: INTEGER);
  570.  INLINE $A89B;
  571. PROCEDURE PenMode(mode: INTEGER);
  572.  INLINE $A89C;
  573. PROCEDURE PenPat(pat: Pattern);
  574.  INLINE $A89D;
  575. PROCEDURE PenNormal;
  576.  INLINE $A89E;
  577. PROCEDURE MoveTo(h: INTEGER;v: INTEGER);
  578.  INLINE $A893;
  579. PROCEDURE Move(dh: INTEGER;dv: INTEGER);
  580.  INLINE $A894;
  581. PROCEDURE LineTo(h: INTEGER;v: INTEGER);
  582.  INLINE $A891;
  583. PROCEDURE Line(dh: INTEGER;dv: INTEGER);
  584.  INLINE $A892;
  585. PROCEDURE TextFont(font: INTEGER);
  586.  INLINE $A887;
  587. PROCEDURE TextFace(face: Style);
  588.  INLINE $A888;
  589. PROCEDURE TextMode(mode: INTEGER);
  590.  INLINE $A889;
  591. PROCEDURE TextSize(size: INTEGER);
  592.  INLINE $A88A;
  593. PROCEDURE SpaceExtra(extra: Fixed);
  594.  INLINE $A88E;
  595. PROCEDURE DrawChar(ch: CHAR);
  596.  INLINE $A883;
  597. PROCEDURE DrawString(s: Str255);
  598.  INLINE $A884;
  599. PROCEDURE DrawText(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER);
  600.  INLINE $A885;
  601. FUNCTION CharWidth(ch: CHAR): INTEGER;
  602.  INLINE $A88D;
  603. FUNCTION StringWidth(s: Str255): INTEGER;
  604.  INLINE $A88C;
  605. FUNCTION TextWidth(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER): INTEGER;
  606.  INLINE $A886;
  607. PROCEDURE MeasureText(count: INTEGER;textAddr: Ptr;charLocs: Ptr);
  608.  INLINE $A837;
  609. PROCEDURE GetFontInfo(VAR info: FontInfo);
  610.  INLINE $A88B;
  611. PROCEDURE ForeColor(color: LONGINT);
  612.  INLINE $A862;
  613. PROCEDURE BackColor(color: LONGINT);
  614.  INLINE $A863;
  615. PROCEDURE ColorBit(whichBit: INTEGER);
  616.  INLINE $A864;
  617. PROCEDURE SetRect(VAR r: Rect;left: INTEGER;top: INTEGER;right: INTEGER;
  618.  bottom: INTEGER);
  619.  INLINE $A8A7;
  620. PROCEDURE OffsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  621.  INLINE $A8A8;
  622. PROCEDURE InsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  623.  INLINE $A8A9;
  624. FUNCTION SectRect(src1: Rect;src2: Rect;VAR dstRect: Rect): BOOLEAN;
  625.  INLINE $A8AA;
  626. PROCEDURE UnionRect(src1: Rect;src2: Rect;VAR dstRect: Rect);
  627.  INLINE $A8AB;
  628. FUNCTION EqualRect(rect1: Rect;rect2: Rect): BOOLEAN;
  629.  INLINE $A8A6;
  630. FUNCTION EmptyRect(r: Rect): BOOLEAN;
  631.  INLINE $A8AE;
  632. PROCEDURE FrameRect(r: Rect);
  633.  INLINE $A8A1;
  634. PROCEDURE PaintRect(r: Rect);
  635.  INLINE $A8A2;
  636. PROCEDURE EraseRect(r: Rect);
  637.  INLINE $A8A3;
  638. PROCEDURE InvertRect(r: Rect);
  639.  INLINE $A8A4;
  640. PROCEDURE FillRect(r: Rect;pat: Pattern);
  641.  INLINE $A8A5;
  642. PROCEDURE FrameOval(r: Rect);
  643.  INLINE $A8B7;
  644. PROCEDURE PaintOval(r: Rect);
  645.  INLINE $A8B8;
  646. PROCEDURE EraseOval(r: Rect);
  647.  INLINE $A8B9;
  648. PROCEDURE InvertOval(r: Rect);
  649.  INLINE $A8BA;
  650. PROCEDURE FillOval(r: Rect;pat: Pattern);
  651.  INLINE $A8BB;
  652. PROCEDURE FrameRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  653.  INLINE $A8B0;
  654. PROCEDURE PaintRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  655.  INLINE $A8B1;
  656. PROCEDURE EraseRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  657.  INLINE $A8B2;
  658. PROCEDURE InvertRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  659.  INLINE $A8B3;
  660. PROCEDURE FillRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  661.  pat: Pattern);
  662.  INLINE $A8B4;
  663. PROCEDURE FrameArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  664.  INLINE $A8BE;
  665. PROCEDURE PaintArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  666.  INLINE $A8BF;
  667. PROCEDURE EraseArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  668.  INLINE $A8C0;
  669. PROCEDURE InvertArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  670.  INLINE $A8C1;
  671. PROCEDURE FillArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pat: Pattern);
  672.  INLINE $A8C2;
  673. FUNCTION NewRgn: RgnHandle;
  674.  INLINE $A8D8;
  675. PROCEDURE OpenRgn;
  676.  INLINE $A8DA;
  677. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  678.  INLINE $A8DB;
  679. FUNCTION BitMapToRegionGlue(region: RgnHandle;bMap: BitMap): OSErr;
  680. FUNCTION BitMapToRegion(region: RgnHandle;bMap: BitMap): OSErr;
  681.  INLINE $A8D7;
  682. PROCEDURE DisposeRgn(rgn: RgnHandle);
  683.  INLINE $A8D9;
  684. PROCEDURE CopyRgn(srcRgn: RgnHandle;dstRgn: RgnHandle);
  685.  INLINE $A8DC;
  686. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  687.  INLINE $A8DD;
  688. PROCEDURE SetRectRgn(rgn: RgnHandle;left: INTEGER;top: INTEGER;right: INTEGER;
  689.  bottom: INTEGER);
  690.  INLINE $A8DE;
  691. PROCEDURE RectRgn(rgn: RgnHandle;r: Rect);
  692.  INLINE $A8DF;
  693. PROCEDURE OffsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  694.  INLINE $A8E0;
  695. PROCEDURE InsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  696.  INLINE $A8E1;
  697. PROCEDURE SectRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  698.  INLINE $A8E4;
  699. PROCEDURE UnionRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  700.  INLINE $A8E5;
  701. PROCEDURE DiffRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  702.  INLINE $A8E6;
  703. PROCEDURE XorRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  704.  INLINE $A8E7;
  705. FUNCTION RectInRgn(r: Rect;rgn: RgnHandle): BOOLEAN;
  706.  INLINE $A8E9;
  707. FUNCTION EqualRgn(rgnA: RgnHandle;rgnB: RgnHandle): BOOLEAN;
  708.  INLINE $A8E3;
  709. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  710.  INLINE $A8E2;
  711. PROCEDURE FrameRgn(rgn: RgnHandle);
  712.  INLINE $A8D2;
  713. PROCEDURE PaintRgn(rgn: RgnHandle);
  714.  INLINE $A8D3;
  715. PROCEDURE EraseRgn(rgn: RgnHandle);
  716.  INLINE $A8D4;
  717. PROCEDURE InvertRgn(rgn: RgnHandle);
  718.  INLINE $A8D5;
  719. PROCEDURE FillRgn(rgn: RgnHandle;pat: Pattern);
  720.  INLINE $A8D6;
  721. PROCEDURE ScrollRect(r: Rect;dh: INTEGER;dv: INTEGER;updateRgn: RgnHandle);
  722.  INLINE $A8EF;
  723. PROCEDURE CopyBits(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  724.  mode: INTEGER;maskRgn: RgnHandle);
  725.  INLINE $A8EC;
  726. PROCEDURE SeedFill(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  727.  height: INTEGER;words: INTEGER;seedH: INTEGER;seedV: INTEGER);
  728.  INLINE $A839;
  729. PROCEDURE CalcMask(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  730.  height: INTEGER;words: INTEGER);
  731.  INLINE $A838;
  732. PROCEDURE CopyMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;srcRect: Rect;
  733.  maskRect: Rect;dstRect: Rect);
  734.  INLINE $A817;
  735. FUNCTION OpenPicture(picFrame: Rect): PicHandle;
  736.  INLINE $A8F3;
  737. PROCEDURE PicComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  738.  INLINE $A8F2;
  739. PROCEDURE ClosePicture;
  740.  INLINE $A8F4;
  741. PROCEDURE DrawPicture(myPicture: PicHandle;dstRect: Rect);
  742.  INLINE $A8F6;
  743. PROCEDURE KillPicture(myPicture: PicHandle);
  744.  INLINE $A8F5;
  745. FUNCTION OpenPoly: PolyHandle;
  746.  INLINE $A8CB;
  747. PROCEDURE ClosePoly;
  748.  INLINE $A8CC;
  749. PROCEDURE KillPoly(poly: PolyHandle);
  750.  INLINE $A8CD;
  751. PROCEDURE OffsetPoly(poly: PolyHandle;dh: INTEGER;dv: INTEGER);
  752.  INLINE $A8CE;
  753. PROCEDURE FramePoly(poly: PolyHandle);
  754.  INLINE $A8C6;
  755. PROCEDURE PaintPoly(poly: PolyHandle);
  756.  INLINE $A8C7;
  757. PROCEDURE ErasePoly(poly: PolyHandle);
  758.  INLINE $A8C8;
  759. PROCEDURE InvertPoly(poly: PolyHandle);
  760.  INLINE $A8C9;
  761. PROCEDURE FillPoly(poly: PolyHandle;pat: Pattern);
  762.  INLINE $A8CA;
  763. PROCEDURE SetPt(VAR pt: Point;h: INTEGER;v: INTEGER);
  764.  INLINE $A880;
  765. PROCEDURE LocalToGlobal(VAR pt: Point);
  766.  INLINE $A870;
  767. PROCEDURE GlobalToLocal(VAR pt: Point);
  768.  INLINE $A871;
  769. FUNCTION Random: INTEGER;
  770.  INLINE $A861;
  771. PROCEDURE StuffHex(thingPtr: Ptr;s: Str255);
  772.  INLINE $A866;
  773. FUNCTION GetPixel(h: INTEGER;v: INTEGER): BOOLEAN;
  774.  INLINE $A865;
  775. PROCEDURE ScalePt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  776.  INLINE $A8F8;
  777. PROCEDURE MapPt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  778.  INLINE $A8F9;
  779. PROCEDURE MapRect(VAR r: Rect;srcRect: Rect;dstRect: Rect);
  780.  INLINE $A8FA;
  781. PROCEDURE MapRgn(rgn: RgnHandle;srcRect: Rect;dstRect: Rect);
  782.  INLINE $A8FB;
  783. PROCEDURE MapPoly(poly: PolyHandle;srcRect: Rect;dstRect: Rect);
  784.  INLINE $A8FC;
  785. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  786.  INLINE $A8EA;
  787. PROCEDURE StdRect(verb: GrafVerb;r: Rect);
  788.  INLINE $A8A0;
  789. PROCEDURE StdRRect(verb: GrafVerb;r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  790.  INLINE $A8AF;
  791. PROCEDURE StdOval(verb: GrafVerb;r: Rect);
  792.  INLINE $A8B6;
  793. PROCEDURE StdArc(verb: GrafVerb;r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  794.  INLINE $A8BD;
  795. PROCEDURE StdPoly(verb: GrafVerb;poly: PolyHandle);
  796.  INLINE $A8C5;
  797. PROCEDURE StdRgn(verb: GrafVerb;rgn: RgnHandle);
  798.  INLINE $A8D1;
  799. PROCEDURE StdBits(VAR srcBits: BitMap;VAR srcRect: Rect;dstRect: Rect;mode: INTEGER;
  800.     maskRgn: RgnHandle);
  801.     INLINE $A8EB;
  802. PROCEDURE StdComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  803.  INLINE $A8F1;
  804. FUNCTION StdTxMeas(byteCount: INTEGER;textAddr: Ptr;VAR numer: Point;VAR denom: Point;
  805.  VAR info: FontInfo): INTEGER;
  806.  INLINE $A8ED;
  807. PROCEDURE StdGetPic(dataPtr: Ptr;byteCount: INTEGER);
  808.  INLINE $A8EE;
  809. PROCEDURE StdPutPic(dataPtr: Ptr;byteCount: INTEGER);
  810.  INLINE $A8F0;
  811. PROCEDURE AddPt(src: Point;VAR dst: Point);
  812.  INLINE $A87E;
  813. FUNCTION EqualPt(pt1: Point;pt2: Point): BOOLEAN;
  814.  INLINE $A881;
  815. FUNCTION PtInRect(pt: Point;r: Rect): BOOLEAN;
  816.  INLINE $A8AD;
  817. PROCEDURE Pt2Rect(pt1: Point;pt2: Point;VAR dstRect: Rect);
  818.  INLINE $A8AC;
  819. PROCEDURE PtToAngle(r: Rect;pt: Point;VAR angle: INTEGER);
  820.  INLINE $A8C3;
  821. FUNCTION PtInRgn(pt: Point;rgn: RgnHandle): BOOLEAN;
  822.  INLINE $A8E8;
  823. PROCEDURE StdText(count: INTEGER;textAddr: Ptr;numer: Point;denom: Point);
  824.  INLINE $A882;
  825. PROCEDURE StdLine(newPt: Point);
  826.  INLINE $A890;
  827. PROCEDURE OpenCPort(port: CGrafPtr);
  828.  INLINE $AA00;
  829. PROCEDURE InitCPort(port: CGrafPtr);
  830.  INLINE $AA01;
  831. PROCEDURE CloseCPort(port: CGrafPtr);
  832.  INLINE $A87D;
  833. FUNCTION NewPixMap: PixMapHandle;
  834.  INLINE $AA03;
  835. PROCEDURE DisposPixMap(pm: PixMapHandle);
  836.  INLINE $AA04;
  837. PROCEDURE DisposePixMap(pm: PixMapHandle);
  838.  INLINE $AA04;
  839. PROCEDURE CopyPixMap(srcPM: PixMapHandle;dstPM: PixMapHandle);
  840.  INLINE $AA05;
  841. FUNCTION NewPixPat: PixPatHandle;
  842.  INLINE $AA07;
  843. PROCEDURE DisposPixPat(pp: PixPatHandle);
  844.  INLINE $AA08;
  845. PROCEDURE DisposePixPat(pp: PixPatHandle);
  846.  INLINE $AA08;
  847. PROCEDURE CopyPixPat(srcPP: PixPatHandle;dstPP: PixPatHandle);
  848.  INLINE $AA09;
  849. PROCEDURE PenPixPat(pp: PixPatHandle);
  850.  INLINE $AA0A;
  851. PROCEDURE BackPixPat(pp: PixPatHandle);
  852.  INLINE $AA0B;
  853. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  854.  INLINE $AA0C;
  855. PROCEDURE MakeRGBPat(pp: PixPatHandle;myColor: RGBColor);
  856.  INLINE $AA0D;
  857. PROCEDURE FillCRect(r: Rect;pp: PixPatHandle);
  858.  INLINE $AA0E;
  859. PROCEDURE FillCOval(r: Rect;pp: PixPatHandle);
  860.  INLINE $AA0F;
  861. PROCEDURE FillCRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  862.  pp: PixPatHandle);
  863.  INLINE $AA10;
  864. PROCEDURE FillCArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pp: PixPatHandle);
  865.  INLINE $AA11;
  866. PROCEDURE FillCRgn(rgn: RgnHandle;pp: PixPatHandle);
  867.  INLINE $AA12;
  868. PROCEDURE FillCPoly(poly: PolyHandle;pp: PixPatHandle);
  869.  INLINE $AA13;
  870. PROCEDURE RGBForeColor(color: RGBColor);
  871.  INLINE $AA14;
  872. PROCEDURE RGBBackColor(color: RGBColor);
  873.  INLINE $AA15;
  874. PROCEDURE SetCPixel(h: INTEGER;v: INTEGER;cPix: RGBColor);
  875.  INLINE $AA16;
  876. PROCEDURE SetPortPix(pm: PixMapHandle);
  877.  INLINE $AA06;
  878. PROCEDURE GetCPixel(h: INTEGER;v: INTEGER;VAR cPix: RGBColor);
  879.  INLINE $AA17;
  880. PROCEDURE GetForeColor(VAR color: RGBColor);
  881.  INLINE $AA19;
  882. PROCEDURE GetBackColor(VAR color: RGBColor);
  883.  INLINE $AA1A;
  884. PROCEDURE SeedCFill(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  885.  seedH: INTEGER;seedV: INTEGER;matchProc: ProcPtr;matchData: LONGINT);
  886.  INLINE $AA50;
  887. PROCEDURE CalcCMask(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  888.  seedRGB: RGBColor;matchProc: ProcPtr;matchData: LONGINT);
  889.  INLINE $AA4F;
  890. FUNCTION OpenCPicture(newHeader: OpenCPicParams): PicHandle;
  891.  INLINE $AA20;
  892. PROCEDURE OpColor(color: RGBColor);
  893.  INLINE $AA21;
  894. PROCEDURE HiliteColor(color: RGBColor);
  895.  INLINE $AA22;
  896. PROCEDURE DisposCTable(cTable: CTabHandle);
  897.  INLINE $AA24;
  898. PROCEDURE DisposeCTable(cTable: CTabHandle);
  899.  INLINE $AA24;
  900. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  901.  INLINE $AA18;
  902. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  903.  INLINE $AA1B;
  904. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  905.  INLINE $AA1C;
  906. PROCEDURE AllocCursor;
  907.  INLINE $AA1D;
  908. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  909.  INLINE $AA26;
  910. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  911.  INLINE $AA26;
  912. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  913.  INLINE $AA1E;
  914. PROCEDURE PlotCIcon(theRect: Rect;theIcon: CIconHandle);
  915.  INLINE $AA1F;
  916. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  917.  INLINE $AA25;
  918. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  919.  INLINE $AA25;
  920. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  921.  INLINE $AA4E;
  922. PROCEDURE CharExtra(extra: Fixed);
  923.  INLINE $AA23;
  924. FUNCTION GetMaxDevice(globalRect: Rect): GDHandle;
  925.  INLINE $AA27;
  926. FUNCTION GetCTSeed: LONGINT;
  927.  INLINE $AA28;
  928. FUNCTION GetDeviceList: GDHandle;
  929.  INLINE $AA29;
  930. FUNCTION GetMainDevice: GDHandle;
  931.  INLINE $AA2A;
  932. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  933.  INLINE $AA2B;
  934. FUNCTION TestDeviceAttribute(gdh: GDHandle;attribute: INTEGER): BOOLEAN;
  935.  INLINE $AA2C;
  936. PROCEDURE SetDeviceAttribute(gdh: GDHandle;attribute: INTEGER;value: BOOLEAN);
  937.  INLINE $AA2D;
  938. PROCEDURE InitGDevice(qdRefNum: INTEGER;mode: LONGINT;gdh: GDHandle);
  939.  INLINE $AA2E;
  940. FUNCTION NewGDevice(refNum: INTEGER;mode: LONGINT): GDHandle;
  941.  INLINE $AA2F;
  942. PROCEDURE DisposGDevice(gdh: GDHandle);
  943.  INLINE $AA30;
  944. PROCEDURE DisposeGDevice(gdh: GDHandle);
  945.  INLINE $AA30;
  946. PROCEDURE SetGDevice(gd: GDHandle);
  947.  INLINE $AA31;
  948. FUNCTION GetGDevice: GDHandle;
  949.  INLINE $AA32;
  950. FUNCTION Color2Index(myColor: RGBColor): LONGINT;
  951.  INLINE $AA33;
  952. PROCEDURE Index2Color(index: LONGINT;VAR aColor: RGBColor);
  953.  INLINE $AA34;
  954. PROCEDURE InvertColor(VAR myColor: RGBColor);
  955.  INLINE $AA35;
  956. FUNCTION RealColor(color: RGBColor): BOOLEAN;
  957.  INLINE $AA36;
  958. PROCEDURE GetSubTable(myColors: CTabHandle;iTabRes: INTEGER;targetTbl: CTabHandle);
  959.  INLINE $AA37;
  960. PROCEDURE MakeITable(cTabH: CTabHandle;iTabH: ITabHandle;res: INTEGER);
  961.  INLINE $AA39;
  962. PROCEDURE AddSearch(searchProc: ProcPtr);
  963.  INLINE $AA3A;
  964. PROCEDURE AddComp(compProc: ProcPtr);
  965.  INLINE $AA3B;
  966. PROCEDURE DelSearch(searchProc: ProcPtr);
  967.  INLINE $AA4C;
  968. PROCEDURE DelComp(compProc: ProcPtr);
  969.  INLINE $AA4D;
  970. PROCEDURE SubPt(src: Point;VAR dst: Point);
  971.  INLINE $A87F;
  972. PROCEDURE SetClientID(id: INTEGER);
  973.  INLINE $AA3C;
  974. PROCEDURE ProtectEntry(index: INTEGER;protect: BOOLEAN);
  975.  INLINE $AA3D;
  976. PROCEDURE ReserveEntry(index: INTEGER;reserve: BOOLEAN);
  977.  INLINE $AA3E;
  978. PROCEDURE SetEntries(start: INTEGER;count: INTEGER;aTable: CSpecArray);
  979.  INLINE $AA3F;
  980. PROCEDURE SaveEntries(srcTable: CTabHandle;resultTable: CTabHandle;VAR selection: ReqListRec);
  981.  INLINE $AA49;
  982. PROCEDURE RestoreEntries(srcTable: CTabHandle;dstTable: CTabHandle;VAR selection: ReqListRec);
  983.  INLINE $AA4A;
  984. FUNCTION QDError: INTEGER;
  985.  INLINE $AA40;
  986. PROCEDURE CopyDeepMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;
  987.  srcRect: Rect;maskRect: Rect;dstRect: Rect;mode: INTEGER;maskRgn: RgnHandle);
  988.  INLINE $AA51;
  989. PROCEDURE DeviceLoop(drawingRgn: RgnHandle;drawingProc: DeviceLoopDrawingProcPtr;
  990.  userData: LONGINT;flags: DeviceLoopFlags);
  991.  INLINE $ABCA;
  992. FUNCTION GetMaskTable: Ptr;
  993.  INLINE $A836,$2E88;
  994.  
  995.  
  996. {$ENDC} { UsingQuickdraw }
  997.  
  998. {$IFC NOT UsingIncludes}
  999.  END.
  1000. {$ENDC}
  1001.  
  1002.